home *** CD-ROM | disk | FTP | other *** search
/ CD Actual 85 / CD Temático 40 Febrero 2004.iso / DOS / testdisk / src / ext2fs / bitops.h next >
Encoding:
C/C++ Source or Header  |  2002-04-03  |  17.1 KB  |  716 lines
  1. /*
  2.  * bitops.h --- Bitmap frobbing code.  The byte swapping routines are
  3.  *     also included here.
  4.  * 
  5.  * Copyright (C) 1993, 1994, 1995, 1996 Theodore Ts'o.
  6.  *
  7.  * %Begin-Header%
  8.  * This file may be redistributed under the terms of the GNU Public
  9.  * License.
  10.  * %End-Header%
  11.  * 
  12.  * i386 bitops operations taken from <asm/bitops.h>, Copyright 1992,
  13.  * Linus Torvalds.
  14.  */
  15.  
  16.  
  17. extern int ext2fs_set_bit(int nr,void * addr);
  18. extern int ext2fs_clear_bit(int nr, void * addr);
  19. extern int ext2fs_test_bit(int nr, const void * addr);
  20. extern __u16 ext2fs_swab16(__u16 val);
  21. extern __u32 ext2fs_swab32(__u32 val);
  22.  
  23. /*
  24.  * EXT2FS bitmap manipulation routines.
  25.  */
  26.  
  27. /* Support for sending warning messages from the inline subroutines */
  28. extern const char *ext2fs_block_string;
  29. extern const char *ext2fs_inode_string;
  30. extern const char *ext2fs_mark_string;
  31. extern const char *ext2fs_unmark_string;
  32. extern const char *ext2fs_test_string;
  33. extern void ext2fs_warn_bitmap(errcode_t errcode, unsigned long arg,
  34.                    const char *description);
  35. extern void ext2fs_warn_bitmap2(ext2fs_generic_bitmap bitmap,
  36.                 int code, unsigned long arg);
  37.  
  38. extern int ext2fs_mark_block_bitmap(ext2fs_block_bitmap bitmap, blk_t block);
  39. extern int ext2fs_unmark_block_bitmap(ext2fs_block_bitmap bitmap,
  40.                        blk_t block);
  41. extern int ext2fs_test_block_bitmap(ext2fs_block_bitmap bitmap, blk_t block);
  42.  
  43. extern int ext2fs_mark_inode_bitmap(ext2fs_inode_bitmap bitmap, ext2_ino_t inode);
  44. extern int ext2fs_unmark_inode_bitmap(ext2fs_inode_bitmap bitmap,
  45.                        ext2_ino_t inode);
  46. extern int ext2fs_test_inode_bitmap(ext2fs_inode_bitmap bitmap, ext2_ino_t inode);
  47.  
  48. extern void ext2fs_fast_mark_block_bitmap(ext2fs_block_bitmap bitmap,
  49.                       blk_t block);
  50. extern void ext2fs_fast_unmark_block_bitmap(ext2fs_block_bitmap bitmap,
  51.                         blk_t block);
  52. extern int ext2fs_fast_test_block_bitmap(ext2fs_block_bitmap bitmap,
  53.                      blk_t block);
  54.  
  55. extern void ext2fs_fast_mark_inode_bitmap(ext2fs_inode_bitmap bitmap,
  56.                       ext2_ino_t inode);
  57. extern void ext2fs_fast_unmark_inode_bitmap(ext2fs_inode_bitmap bitmap,
  58.                         ext2_ino_t inode);
  59. extern int ext2fs_fast_test_inode_bitmap(ext2fs_inode_bitmap bitmap,
  60.                      ext2_ino_t inode);
  61. extern blk_t ext2fs_get_block_bitmap_start(ext2fs_block_bitmap bitmap);
  62. extern ext2_ino_t ext2fs_get_inode_bitmap_start(ext2fs_inode_bitmap bitmap);
  63. extern blk_t ext2fs_get_block_bitmap_end(ext2fs_block_bitmap bitmap);
  64. extern ext2_ino_t ext2fs_get_inode_bitmap_end(ext2fs_inode_bitmap bitmap);
  65.  
  66. extern void ext2fs_mark_block_bitmap_range(ext2fs_block_bitmap bitmap,
  67.                        blk_t block, int num);
  68. extern void ext2fs_unmark_block_bitmap_range(ext2fs_block_bitmap bitmap,
  69.                          blk_t block, int num);
  70. extern int ext2fs_test_block_bitmap_range(ext2fs_block_bitmap bitmap,
  71.                       blk_t block, int num);
  72. extern void ext2fs_fast_mark_block_bitmap_range(ext2fs_block_bitmap bitmap,
  73.                         blk_t block, int num);
  74. extern void ext2fs_fast_unmark_block_bitmap_range(ext2fs_block_bitmap bitmap,
  75.                           blk_t block, int num);
  76. extern int ext2fs_fast_test_block_bitmap_range(ext2fs_block_bitmap bitmap,
  77.                            blk_t block, int num);
  78. extern void ext2fs_set_bitmap_padding(ext2fs_generic_bitmap map);
  79.  
  80. /* These two routines moved to gen_bitmap.c */
  81. extern int ext2fs_mark_generic_bitmap(ext2fs_generic_bitmap bitmap,
  82.                      __u32 bitno);
  83. extern int ext2fs_unmark_generic_bitmap(ext2fs_generic_bitmap bitmap,
  84.                        blk_t bitno);
  85. /*
  86.  * The inline routines themselves...
  87.  * 
  88.  * If NO_INLINE_FUNCS is defined, then we won't try to do inline
  89.  * functions at all; they will be included as normal functions in
  90.  * inline.c
  91.  */
  92. #ifdef NO_INLINE_FUNCS
  93. #if (defined(__GNUC__) && (defined(__i386__) || defined(__i486__) || \
  94.                defined(__i586__) || defined(__mc68000__) || \
  95.                defined(__sparc__)))
  96.     /* This prevents bitops.c from trying to include the C */
  97.     /* function version of these functions */
  98. #define _EXT2_HAVE_ASM_BITOPS_
  99. #endif
  100. #endif /* NO_INLINE_FUNCS */
  101.  
  102. #if (defined(INCLUDE_INLINE_FUNCS) || !defined(NO_INLINE_FUNCS))
  103. #ifdef INCLUDE_INLINE_FUNCS
  104. #define _INLINE_ extern
  105. #else
  106. #ifdef __GNUC__
  107. #define _INLINE_ extern __inline__
  108. #else                /* For Watcom C */
  109. #define _INLINE_ extern inline
  110. #endif
  111. #endif
  112.  
  113. #if ((defined __GNUC__) && !defined(_EXT2_USE_C_VERSIONS_) && \
  114.      (defined(__i386__) || defined(__i486__) || defined(__i586__)))
  115.  
  116. #define _EXT2_HAVE_ASM_BITOPS_
  117. #define _EXT2_HAVE_ASM_SWAB_
  118. #define _EXT2_HAVE_ASM_FINDBIT_
  119.  
  120. /*
  121.  * These are done by inline assembly for speed reasons.....
  122.  *
  123.  * All bitoperations return 0 if the bit was cleared before the
  124.  * operation and != 0 if it was not.  Bit 0 is the LSB of addr; bit 32
  125.  * is the LSB of (addr+1).
  126.  */
  127.  
  128. /*
  129.  * Some hacks to defeat gcc over-optimizations..
  130.  */
  131. struct __dummy_h { unsigned long a[100]; };
  132. #define EXT2FS_ADDR (*(struct __dummy_h *) addr)
  133. #define EXT2FS_CONST_ADDR (*(const struct __dummy_h *) addr)    
  134.  
  135. _INLINE_ int ext2fs_set_bit(int nr, void * addr)
  136. {
  137.     int oldbit;
  138.  
  139.     __asm__ __volatile__("btsl %2,%1\n\tsbbl %0,%0"
  140.         :"=r" (oldbit),"=m" (EXT2FS_ADDR)
  141.         :"r" (nr));
  142.     return oldbit;
  143. }
  144.  
  145. _INLINE_ int ext2fs_clear_bit(int nr, void * addr)
  146. {
  147.     int oldbit;
  148.  
  149.     __asm__ __volatile__("btrl %2,%1\n\tsbbl %0,%0"
  150.         :"=r" (oldbit),"=m" (EXT2FS_ADDR)
  151.         :"r" (nr));
  152.     return oldbit;
  153. }
  154.  
  155. _INLINE_ int ext2fs_test_bit(int nr, const void * addr)
  156. {
  157.     int oldbit;
  158.  
  159.     __asm__ __volatile__("btl %2,%1\n\tsbbl %0,%0"
  160.         :"=r" (oldbit)
  161.         :"m" (EXT2FS_CONST_ADDR),"r" (nr));
  162.     return oldbit;
  163. }
  164.  
  165. #if 0
  166. _INLINE_ int ext2fs_find_first_bit_set(void * addr, unsigned size)
  167. {
  168.     int d0, d1, d2;
  169.     int res;
  170.  
  171.     if (!size)
  172.         return 0;
  173.     /* This looks at memory. Mark it volatile to tell gcc not to move it around */
  174.     __asm__ __volatile__(
  175.         "cld\n\t"                 
  176.         "xorl %%eax,%%eax\n\t"
  177.         "xorl %%edx,%%edx\n\t"
  178.         "repe; scasl\n\t"
  179.         "je 1f\n\t"
  180.         "movl -4(%%edi),%%eax\n\t"
  181.         "subl $4,%%edi\n\t"
  182.         "bsfl %%eax,%%edx\n"
  183.         "1:\tsubl %%esi,%%edi\n\t"
  184.         "shll $3,%%edi\n\t"
  185.         "addl %%edi,%%edx"
  186.         :"=d" (res), "=&c" (d0), "=&D" (d1), "=&a" (d2)
  187.         :"1" ((size + 31) >> 5), "2" (addr), "S" (addr));
  188.     return res;
  189. }
  190.  
  191. _INLINE_ int ext2fs_find_next_bit_set (void * addr, int size, int offset)
  192. {
  193.     unsigned long * p = ((unsigned long *) addr) + (offset >> 5);
  194.     int set = 0, bit = offset & 31, res;
  195.     
  196.     if (bit) {
  197.         /*
  198.          * Look for zero in first byte
  199.          */
  200.         __asm__("bsfl %1,%0\n\t"
  201.             "jne 1f\n\t"
  202.             "movl $32, %0\n"
  203.             "1:"
  204.             : "=r" (set)
  205.             : "r" (*p >> bit));
  206.         if (set < (32 - bit))
  207.             return set + offset;
  208.         set = 32 - bit;
  209.         p++;
  210.     }
  211.     /*
  212.      * No bit found yet, search remaining full bytes for a bit
  213.      */
  214.     res = ext2fs_find_first_bit_set(p, size - 32 * (p - (unsigned long *) addr));
  215.     return (offset + set + res);
  216. }
  217. #endif
  218.  
  219. #ifdef EXT2FS_ENABLE_SWAPFS
  220. _INLINE_ __u32 ext2fs_swab32(__u32 val)
  221. {
  222. #ifdef EXT2FS_REQUIRE_486
  223.     __asm__("bswap %0" : "=r" (val) : "0" (val));
  224. #else
  225.     __asm__("xchgb %b0,%h0\n\t"    /* swap lower bytes    */
  226.         "rorl $16,%0\n\t"    /* swap words        */
  227.         "xchgb %b0,%h0"        /* swap higher bytes    */
  228.         :"=q" (val)
  229.         : "0" (val));
  230. #endif
  231.     return val;
  232. }
  233.  
  234. _INLINE_ __u16 ext2fs_swab16(__u16 val)
  235. {
  236.     __asm__("xchgb %b0,%h0"        /* swap bytes        */ \
  237.         : "=q" (val) \
  238.         :  "0" (val)); \
  239.         return val;
  240. }
  241. #endif
  242.  
  243. #undef EXT2FS_ADDR
  244.  
  245. #endif    /* i386 */
  246.  
  247. #ifdef __mc68000__
  248.  
  249. #define _EXT2_HAVE_ASM_BITOPS_
  250.  
  251. _INLINE_ int ext2fs_set_bit(int nr,void * addr)
  252. {
  253.     char retval;
  254.  
  255.     __asm__ __volatile__ ("bfset %2@{%1:#1}; sne %0"
  256.          : "=d" (retval) : "d" (nr^7), "a" (addr));
  257.  
  258.     return retval;
  259. }
  260.  
  261. _INLINE_ int ext2fs_clear_bit(int nr, void * addr)
  262. {
  263.     char retval;
  264.  
  265.     __asm__ __volatile__ ("bfclr %2@{%1:#1}; sne %0"
  266.          : "=d" (retval) : "d" (nr^7), "a" (addr));
  267.  
  268.     return retval;
  269. }
  270.  
  271. _INLINE_ int ext2fs_test_bit(int nr, const void * addr)
  272. {
  273.     char retval;
  274.  
  275.     __asm__ __volatile__ ("bftst %2@{%1:#1}; sne %0"
  276.          : "=d" (retval) : "d" (nr^7), "a" (addr));
  277.  
  278.     return retval;
  279. }
  280.  
  281. #endif /* __mc68000__ */
  282.  
  283. #ifdef __sparc__
  284.  
  285. #define _EXT2_HAVE_ASM_BITOPS_
  286.  
  287. #ifndef EXT2_OLD_BITOPS
  288.  
  289. /*
  290.  * Do the bitops so that we are compatible with the standard i386
  291.  * convention.
  292.  */
  293.  
  294. _INLINE_ int ext2fs_set_bit(int nr,void * addr)
  295. {
  296. #if 1
  297.     int        mask;
  298.     unsigned char    *ADDR = (unsigned char *) addr;
  299.  
  300.     ADDR += nr >> 3;
  301.     mask = 1 << (nr & 0x07);
  302.     __asm__ __volatile__("ldub    [%0], %%g6\n\t"
  303.                  "or    %%g6, %2, %%g5\n\t"
  304.                  "stb    %%g5, [%0]\n\t"
  305.                  "and    %%g6, %2, %0\n"
  306.     : "=&r" (ADDR)
  307.     : "0" (ADDR), "r" (mask)
  308.     : "g5", "g6");
  309.     return (int) ADDR;
  310. #else
  311.     int        mask, retval;
  312.     unsigned char    *ADDR = (unsigned char *) addr;
  313.  
  314.     ADDR += nr >> 3;
  315.     mask = 1 << (nr & 0x07);
  316.     retval = (mask & *ADDR) != 0;
  317.     *ADDR |= mask;
  318.     return retval;
  319. #endif
  320. }
  321.  
  322. _INLINE_ int ext2fs_clear_bit(int nr, void * addr)
  323. {
  324. #if 1
  325.     int        mask;
  326.     unsigned char    *ADDR = (unsigned char *) addr;
  327.  
  328.     ADDR += nr >> 3;
  329.     mask = 1 << (nr & 0x07);
  330.     __asm__ __volatile__("ldub    [%0], %%g6\n\t"
  331.                  "andn    %%g6, %2, %%g5\n\t"
  332.                  "stb    %%g5, [%0]\n\t"
  333.                  "and    %%g6, %2, %0\n"
  334.     : "=&r" (ADDR)
  335.     : "0" (ADDR), "r" (mask)
  336.     : "g5", "g6");
  337.     return (int) ADDR;
  338.     
  339. #else
  340.     int        mask, retval;
  341.     unsigned char    *ADDR = (unsigned char *) addr;
  342.  
  343.     ADDR += nr >> 3;
  344.     mask = 1 << (nr & 0x07);
  345.     retval = (mask & *ADDR) != 0;
  346.     *ADDR &= ~mask;
  347.     return retval;
  348. #endif
  349. }
  350.  
  351. _INLINE_ int ext2fs_test_bit(int nr, const void * addr)
  352. {
  353.     int            mask;
  354.     const unsigned char    *ADDR = (const unsigned char *) addr;
  355.  
  356.     ADDR += nr >> 3;
  357.     mask = 1 << (nr & 0x07);
  358.     return ((mask & *ADDR) != 0);
  359. }
  360.  
  361. #else
  362.  
  363. /* Do things the old, unplesant way. */
  364.  
  365. _INLINE_ int ext2fs_set_bit(int nr, void *addr)
  366. {
  367.     int        mask, retval;
  368.     unsigned long    *ADDR = (unsigned long *) addr;
  369.  
  370.     ADDR += nr >> 5;
  371.     mask = 1 << (nr & 31);
  372.     retval = ((mask & *ADDR) != 0);
  373.     *ADDR |= mask;
  374.     return retval;
  375. }
  376.  
  377. _INLINE_ int ext2fs_clear_bit(int nr, void *addr)
  378. {
  379.     int        mask, retval;
  380.     unsigned long    *ADDR = (unsigned long *) addr;
  381.  
  382.     ADDR += nr >> 5;
  383.     mask = 1 << (nr & 31);
  384.     retval = ((mask & *ADDR) != 0);
  385.     *ADDR &= ~mask;
  386.     return retval;
  387. }
  388.  
  389. _INLINE_ int ext2fs_test_bit(int nr, const void *addr)
  390. {
  391.     int            mask;
  392.     const unsigned long    *ADDR = (const unsigned long *) addr;
  393.  
  394.     ADDR += nr >> 5;
  395.     mask = 1 << (nr & 31);
  396.     return ((mask & *ADDR) != 0);
  397. }
  398. #endif
  399.  
  400. #endif /* __sparc__ */
  401.  
  402. #if !defined(_EXT2_HAVE_ASM_SWAB_) && defined(EXT2FS_ENABLE_SWAPFS)
  403.  
  404. _INLINE_ __u16 ext2fs_swab16(__u16 val)
  405. {
  406.     return (val >> 8) | (val << 8);
  407. }
  408.  
  409. _INLINE_ __u32 ext2fs_swab32(__u32 val)
  410. {
  411.     return ((val>>24) | ((val>>8)&0xFF00) |
  412.         ((val<<8)&0xFF0000) | (val<<24));
  413. }
  414.  
  415. #endif /* !_EXT2_HAVE_ASM_SWAB */
  416.  
  417. #if !defined(_EXT2_HAVE_ASM_FINDBIT_)
  418. _INLINE_ int ext2fs_find_first_bit_set(void * addr, unsigned size)
  419. {
  420.     char    *cp = (unsigned char *) addr;
  421.     int     res = 0, d0;
  422.  
  423.     if (!size)
  424.         return 0;
  425.  
  426.     while ((size > res) && (*cp == 0)) {
  427.         cp++;
  428.         res += 8;
  429.     }
  430.     d0 = ffs(*cp);
  431.     if (d0 == 0)
  432.         return size;
  433.     
  434.     return res + d0 - 1;
  435. }
  436.  
  437. _INLINE_ int ext2fs_find_next_bit_set (void * addr, int size, int offset)
  438. {
  439.     unsigned char * p;
  440.     int set = 0, bit = offset & 7, res = 0, d0;
  441.     
  442.     res = offset >> 3;
  443.     p = ((unsigned char *) addr) + res;
  444.     
  445.     if (bit) {
  446.         set = ffs(*p & ~((1 << bit) - 1));
  447.         if (set)
  448.             return (offset & ~7) + set - 1;
  449.         p++;
  450.         res += 8;
  451.     }
  452.     while ((size > res) && (*p == 0)) {
  453.         p++;
  454.         res += 8;
  455.     }
  456.     d0 = ffs(*p);
  457.     if (d0 == 0)
  458.         return size;
  459.  
  460.     return (res + d0 - 1);
  461. }
  462. #endif    
  463.  
  464. _INLINE_ int ext2fs_test_generic_bitmap(ext2fs_generic_bitmap bitmap,
  465.                     blk_t bitno);
  466.  
  467. _INLINE_ int ext2fs_test_generic_bitmap(ext2fs_generic_bitmap bitmap,
  468.                     blk_t bitno)
  469. {
  470.     if ((bitno < bitmap->start) || (bitno > bitmap->end)) {
  471.         ext2fs_warn_bitmap2(bitmap, EXT2FS_TEST_ERROR, bitno);
  472.         return 0;
  473.     }
  474.     return ext2fs_test_bit(bitno - bitmap->start, bitmap->bitmap);
  475. }
  476.  
  477. _INLINE_ int ext2fs_mark_block_bitmap(ext2fs_block_bitmap bitmap,
  478.                        blk_t block)
  479. {
  480.     return ext2fs_mark_generic_bitmap((ext2fs_generic_bitmap)
  481.                        bitmap,
  482.                       block);
  483. }
  484.  
  485. _INLINE_ int ext2fs_unmark_block_bitmap(ext2fs_block_bitmap bitmap,
  486.                      blk_t block)
  487. {
  488.     return ext2fs_unmark_generic_bitmap((ext2fs_generic_bitmap) bitmap, 
  489.                         block);
  490. }
  491.  
  492. _INLINE_ int ext2fs_test_block_bitmap(ext2fs_block_bitmap bitmap,
  493.                        blk_t block)
  494. {
  495.     return ext2fs_test_generic_bitmap((ext2fs_generic_bitmap) bitmap, 
  496.                       block);
  497. }
  498.  
  499. _INLINE_ int ext2fs_mark_inode_bitmap(ext2fs_inode_bitmap bitmap,
  500.                        ext2_ino_t inode)
  501. {
  502.     return ext2fs_mark_generic_bitmap((ext2fs_generic_bitmap) bitmap, 
  503.                       inode);
  504. }
  505.  
  506. _INLINE_ int ext2fs_unmark_inode_bitmap(ext2fs_inode_bitmap bitmap,
  507.                      ext2_ino_t inode)
  508. {
  509.     return ext2fs_unmark_generic_bitmap((ext2fs_generic_bitmap) bitmap, 
  510.                      inode);
  511. }
  512.  
  513. _INLINE_ int ext2fs_test_inode_bitmap(ext2fs_inode_bitmap bitmap,
  514.                        ext2_ino_t inode)
  515. {
  516.     return ext2fs_test_generic_bitmap((ext2fs_generic_bitmap) bitmap, 
  517.                       inode);
  518. }
  519.  
  520. _INLINE_ void ext2fs_fast_mark_block_bitmap(ext2fs_block_bitmap bitmap,
  521.                         blk_t block)
  522. {
  523. #ifdef EXT2FS_DEBUG_FAST_OPS
  524.     if ((block < bitmap->start) || (block > bitmap->end)) {
  525.         ext2fs_warn_bitmap(EXT2_ET_BAD_BLOCK_MARK, block,
  526.                    bitmap->description);
  527.         return;
  528.     }
  529. #endif    
  530.     ext2fs_set_bit(block - bitmap->start, bitmap->bitmap);
  531. }
  532.  
  533. _INLINE_ void ext2fs_fast_unmark_block_bitmap(ext2fs_block_bitmap bitmap,
  534.                           blk_t block)
  535. {
  536. #ifdef EXT2FS_DEBUG_FAST_OPS
  537.     if ((block < bitmap->start) || (block > bitmap->end)) {
  538.         ext2fs_warn_bitmap(EXT2_ET_BAD_BLOCK_UNMARK,
  539.                    block, bitmap->description);
  540.         return;
  541.     }
  542. #endif
  543.     ext2fs_clear_bit(block - bitmap->start, bitmap->bitmap);
  544. }
  545.  
  546. _INLINE_ int ext2fs_fast_test_block_bitmap(ext2fs_block_bitmap bitmap,
  547.                         blk_t block)
  548. {
  549. #ifdef EXT2FS_DEBUG_FAST_OPS
  550.     if ((block < bitmap->start) || (block > bitmap->end)) {
  551.         ext2fs_warn_bitmap(EXT2_ET_BAD_BLOCK_TEST,
  552.                    block, bitmap->description);
  553.         return 0;
  554.     }
  555. #endif
  556.     return ext2fs_test_bit(block - bitmap->start, bitmap->bitmap);
  557. }
  558.  
  559. _INLINE_ void ext2fs_fast_mark_inode_bitmap(ext2fs_inode_bitmap bitmap,
  560.                         ext2_ino_t inode)
  561. {
  562. #ifdef EXT2FS_DEBUG_FAST_OPS
  563.     if ((inode < bitmap->start) || (inode > bitmap->end)) {
  564.         ext2fs_warn_bitmap(EXT2_ET_BAD_INODE_MARK,
  565.                    inode, bitmap->description);
  566.         return;
  567.     }
  568. #endif
  569.     ext2fs_set_bit(inode - bitmap->start, bitmap->bitmap);
  570. }
  571.  
  572. _INLINE_ void ext2fs_fast_unmark_inode_bitmap(ext2fs_inode_bitmap bitmap,
  573.                           ext2_ino_t inode)
  574. {
  575. #ifdef EXT2FS_DEBUG_FAST_OPS
  576.     if ((inode < bitmap->start) || (inode > bitmap->end)) {
  577.         ext2fs_warn_bitmap(EXT2_ET_BAD_INODE_UNMARK,
  578.                    inode, bitmap->description);
  579.         return;
  580.     }
  581. #endif
  582.     ext2fs_clear_bit(inode - bitmap->start, bitmap->bitmap);
  583. }
  584.  
  585. _INLINE_ int ext2fs_fast_test_inode_bitmap(ext2fs_inode_bitmap bitmap,
  586.                        ext2_ino_t inode)
  587. {
  588. #ifdef EXT2FS_DEBUG_FAST_OPS
  589.     if ((inode < bitmap->start) || (inode > bitmap->end)) {
  590.         ext2fs_warn_bitmap(EXT2_ET_BAD_INODE_TEST,
  591.                    inode, bitmap->description);
  592.         return 0;
  593.     }
  594. #endif
  595.     return ext2fs_test_bit(inode - bitmap->start, bitmap->bitmap);
  596. }
  597.  
  598. _INLINE_ blk_t ext2fs_get_block_bitmap_start(ext2fs_block_bitmap bitmap)
  599. {
  600.     return bitmap->start;
  601. }
  602.  
  603. _INLINE_ ext2_ino_t ext2fs_get_inode_bitmap_start(ext2fs_inode_bitmap bitmap)
  604. {
  605.     return bitmap->start;
  606. }
  607.  
  608. _INLINE_ blk_t ext2fs_get_block_bitmap_end(ext2fs_block_bitmap bitmap)
  609. {
  610.     return bitmap->end;
  611. }
  612.  
  613. _INLINE_ ext2_ino_t ext2fs_get_inode_bitmap_end(ext2fs_inode_bitmap bitmap)
  614. {
  615.     return bitmap->end;
  616. }
  617.  
  618. _INLINE_ int ext2fs_test_block_bitmap_range(ext2fs_block_bitmap bitmap,
  619.                         blk_t block, int num)
  620. {
  621.     int    i;
  622.  
  623.     if ((block < bitmap->start) || (block+num-1 > bitmap->end)) {
  624.         ext2fs_warn_bitmap(EXT2_ET_BAD_BLOCK_TEST,
  625.                    block, bitmap->description);
  626.         return 0;
  627.     }
  628.     for (i=0; i < num; i++) {
  629.         if (ext2fs_fast_test_block_bitmap(bitmap, block+i))
  630.             return 0;
  631.     }
  632.     return 1;
  633. }
  634.  
  635. _INLINE_ int ext2fs_fast_test_block_bitmap_range(ext2fs_block_bitmap bitmap,
  636.                          blk_t block, int num)
  637. {
  638.     int    i;
  639.  
  640. #ifdef EXT2FS_DEBUG_FAST_OPS
  641.     if ((block < bitmap->start) || (block+num-1 > bitmap->end)) {
  642.         ext2fs_warn_bitmap(EXT2_ET_BAD_BLOCK_TEST,
  643.                    block, bitmap->description);
  644.         return 0;
  645.     }
  646. #endif
  647.     for (i=0; i < num; i++) {
  648.         if (ext2fs_fast_test_block_bitmap(bitmap, block+i))
  649.             return 0;
  650.     }
  651.     return 1;
  652. }
  653.  
  654. _INLINE_ void ext2fs_mark_block_bitmap_range(ext2fs_block_bitmap bitmap,
  655.                          blk_t block, int num)
  656. {
  657.     int    i;
  658.     
  659.     if ((block < bitmap->start) || (block+num-1 > bitmap->end)) {
  660.         ext2fs_warn_bitmap(EXT2_ET_BAD_BLOCK_MARK, block,
  661.                    bitmap->description);
  662.         return;
  663.     }
  664.     for (i=0; i < num; i++)
  665.         ext2fs_set_bit(block + i - bitmap->start, bitmap->bitmap);
  666. }
  667.  
  668. _INLINE_ void ext2fs_fast_mark_block_bitmap_range(ext2fs_block_bitmap bitmap,
  669.                           blk_t block, int num)
  670. {
  671.     int    i;
  672.     
  673. #ifdef EXT2FS_DEBUG_FAST_OPS
  674.     if ((block < bitmap->start) || (block+num-1 > bitmap->end)) {
  675.         ext2fs_warn_bitmap(EXT2_ET_BAD_BLOCK_MARK, block,
  676.                    bitmap->description);
  677.         return;
  678.     }
  679. #endif    
  680.     for (i=0; i < num; i++)
  681.         ext2fs_set_bit(block + i - bitmap->start, bitmap->bitmap);
  682. }
  683.  
  684. _INLINE_ void ext2fs_unmark_block_bitmap_range(ext2fs_block_bitmap bitmap,
  685.                            blk_t block, int num)
  686. {
  687.     int    i;
  688.     
  689.     if ((block < bitmap->start) || (block+num-1 > bitmap->end)) {
  690.         ext2fs_warn_bitmap(EXT2_ET_BAD_BLOCK_UNMARK, block,
  691.                    bitmap->description);
  692.         return;
  693.     }
  694.     for (i=0; i < num; i++)
  695.         ext2fs_clear_bit(block + i - bitmap->start, bitmap->bitmap);
  696. }
  697.  
  698. _INLINE_ void ext2fs_fast_unmark_block_bitmap_range(ext2fs_block_bitmap bitmap,
  699.                             blk_t block, int num)
  700. {
  701.     int    i;
  702.     
  703. #ifdef EXT2FS_DEBUG_FAST_OPS
  704.     if ((block < bitmap->start) || (block+num-1 > bitmap->end)) {
  705.         ext2fs_warn_bitmap(EXT2_ET_BAD_BLOCK_UNMARK, block,
  706.                    bitmap->description);
  707.         return;
  708.     }
  709. #endif    
  710.     for (i=0; i < num; i++)
  711.         ext2fs_clear_bit(block + i - bitmap->start, bitmap->bitmap);
  712. }
  713. #undef _INLINE_
  714. #endif
  715.  
  716.